10.2 Die Klasse »String« 

String-Variablen repräsentieren Zeichenfolgen mit einem ganz wesentlichem Charakteristikum: Sie sind unveränderlich. Ändern Sie den Inhalt einer Zeichenfolgevariablen durch eine neue Zuweisung, wird ein neues String-Objekt erzeugt und das alte verworfen. Der Preis für dieses Verhaltens ist eine Verschlechterung der Performance einer Anwendung, wenn der Inhalt einer string-Variablen sehr häufig geändert wird. Sie sollten in solchen Fällen besser auf die Klasse StringBuilder zurückgreifen, die diesen Nachteil nicht hat. Verschwiegen werden darf dabei jedoch nicht, dass die Fähigkeiten einer StringBuilder-Zeichenfolge deutlich spärlicher sind als die einer string-Zeichenfolge.

Obwohl der Typ String zu den elementaren Datentypen gezählt wird, handelt es sich bei diesen Objekten um Referenz- und nicht um Wertetypen. Intern verwaltet die Common Language Runtime eine Tabelle, die jeden String einer Anwendung enthält. Wenn Sie zur Laufzeit ein neues String-Objekt erzeugen, wird zuerst die Tabelle nach einem identischen String durchsucht. Ist er bereits vorhanden, wird der neuen String-Variablen eine Referenz auf die bereits existierende Instanz zurückgeliefert, andernfalls wird der Pool vergrößert.

10.2.1 Das Erzeugen eines Strings 

Im einfachsten Fall wird ein Objekt vom Typ String durch eine einfache Deklaration erzeugt:

Das ist der Weg, den wir bisher meistens beschritten haben und der wohl auch die Regel darstellt. Es gibt aber noch weitere Möglichkeiten. Dazu sind in der Klasse String auch mehrere Konstruktoren definiert, von denen drei besonders interessant sind:

Allen drei Konstruktoren kommt eine besondere Bedeutung zu, weil mit ihnen Sonderfälle abgedeckt werden. Betrachten wir zunächst die erste Erstellungsroutine. Dieser wird ein char-Array übergeben, aus dem das String-Objekt erstellt wird:

Dieses Codefragment bildet aus dem char-Array die Zeichenfolge »C#.NET«.

Der zweite Konstruktor dient dazu, eine Zeichenfolge zu erzeugen, die sich aus einer bestimmten Anzahl gleicher Zeichen zusammensetzt. Benötigen Sie beispielsweise eine Zeichenfolge aus zehn »*«, könnten Sie das mit

erreichen.

Der letzte Konstruktor liest aus einem gegebenen char-Array beginnend ab einer bestimmten Position eine gewisse Anzahl von Zeichen in eine Zeichenfolge ein. Dem ersten Parameter übergeben Sie das char-Array, dem zweiten die Startposition und dem letzten die Anzahl der Zeichen, die ab der spezifizierten Startposition aus dem char-Array in das String-Objekt eingelesen werden sollen. Sie müssen dabei berücksichtigen, dass die Position des ersten Elements 0 ist. Wollen Sie aus dem char-Array

nur die drei Buchstaben »u«, »a« und »l« in den String schreiben, müsste der Konstruktoraufruf wie folgt lauten:

Ganz am Ende sind wir noch nicht angelangt, was die Erzeugung eines String-Objekts angeht. Sie können nämlich ein char-Array auch auf eine andere Art einer String-Referenz zuweisen:

Die String-Referenz enthält nun die aus den Elementen des Arrays gebildete Zeichenfolge.

10.2.2 Unveränderliche »String«-Objekte 

Am Anfang dieses Abschnitts haben Sie gelesen, dass Sie einer String-Variablen zwar eine neue Zeichenfolge zuweisen können, dabei aber im Hintergrund unbemerkt das alte Objekt zerstört und ein neues erzeugt wird, dem die veränderte Zeichenfolge zugewiesen wird.

Dieses wollen wir natürlich auch noch beweisen. Dazu bedienen wir uns der von Object geerbten Methode GetHashCode. Wenn tatsächlich ein neues Objekt erzeugt wird, muss sich auch der Hashcode ändern. Wir können das mit dem folgenden Codefragment überprüfen:

Es werden zwei unterschiedliche Werte ausgegeben, welche die vorher gemachte Aussage bestätigen. Dass ein String-Objekt nicht verändert werden kann, ist nur ein typisches Charakteristikum, es gibt noch ein zweites. Betrachten Sie hierzu den folgenden Code:

Es sind zwei Variablen vom Typ string deklariert. Beide werden mit derselben Zeichenfolge initialisiert und anschließend der Hashcode der beiden Objekte miteinander verglichen. Sie werden feststellen, dass die beiden Hashcodes identisch sind. Das bedeutet, dass beide Variablen dieselbe Speicheradresse referenzieren. Der Vorteil, der aus dieser typspezifischen Eigenschaft gezogen werden kann, nämlich die Schonung von Speicherressourcen, kommt natürlich nur dann zum Tragen, wenn innerhalb einer Anwendung viele gleich lautende Strings aktiv sind oder andererseits nur ein paar wenige, deren Inhalt dann aber die ansonsten üblichen String-Längen deutlich übertrifft.

10.2.3 Die Eigenschaften von »String« 

String weist nur zwei Eigenschaften auf: Length und Chars. Length liefert die Anzahl der Zeichen, und mit Chars können Sie auf ein einzelnes Zeichen aus der Zeichenfolge zugreifen. Die Definition von Chars, die in C# als Indexer implementiert ist, lautet wie folgt:

Übergeben wird dem Indexer eine Zahl, welche die Position eines Zeichens innerhalb der Zeichenfolge beschreibt, z.B.:

Die char-Variable enthält damit das Zeichen »L«.

Im folgenden Beispiel wird eine Methode entwickelt, der eine Zeichenfolge übergeben wird, deren Abfolge unter Zuhilfenahme des Indexers (also der Chars-Eigenschaft) umgekehrt wird.

In der Methode Reverse wird ein char-Array von der Länge der Zeichenfolge erzeugt, die wir über Length abrufen. Innerhalb einer Schleife, die vom ersten bis zum letzten Index durchlaufen wird, werden die einzelnen Elemente des neuen char-Arrays initialisiert. Die Schleifenvariable wird dazu benutzt, um die übergebene Zeichenfolge beginnend vom letzten Element rückwärts bis zum ersten, mit 0 indizierten, zu durchlaufen. Das entsprechende Zeichen wird in das Array geschrieben.

Zum Schluss bedienen wir uns des passenden String-Konstruktors und schreiben die Referenz auf das char-Array in den Parameter. An der Konsole wird die Ausgabe der umgekehrten Zeichenfolge ausgegeben:

10.2.4 Die Methoden der Klasse »String« 

Sie werden sich oft mit der einfachen Existenz einer Zeichenfolge nicht zufrieden geben, da es sehr häufig vorkommt, dass Zeichenfolgen verglichen oder manipuliert werden müssen oder eine formatierte Ausgabe erwünscht ist. Die Klasse String bietet zu diesem Zweck eine Reihe von Methoden an, die wir uns nun ansehen wollen.

Zeichenfolgen-Vergleiche

Um zwei Zeichenfolgen zu vergleichen, haben Sie die Qual der Wahl, denn dazu stehen Ihnen mit Equals, Compare, CompareTo und CompareOrdinal gleich vier Methoden zur Verfügung. Alle sind sich ziemlich ähnlich und unterscheiden sich nur in kleinen Nuancen.

Bekanntlich werden mit Equals standardmäßig zwei Referenzen miteinander verglichen. Da zwei String-Variablen, die denselben Inhalt haben, ein und dasselbe Objekt im Speicher referenzieren, können Sie diese Methode auch dazu benutzen, den Inhalt der Variablen miteinander zu vergleichen. Verweisen zwei Strings auf dieselbe Speicheradresse, muss deren Inhalt zwangsläufig identisch sein.

Sehr ähnlich arbeitet auch Compare. Die Methode liefert jedoch keinen boolescher Wert, sondern einen Integer, der entweder < 0, 0 oder > 0 ist. Dazu ein Beispiel:

Das Ergebnis an der Konsole bestätigt, dass beide Zeichenfolgen denselben Inhalt aufweisen. Ändern wir nun einen der beiden Strings von »Hallo« in »hallo« und testen noch einmal. Diesmal erhalten wir keine Bestätigung, was uns zu folgender Aussage führt:

Die Interpretation der Rückgabewerte von Compare, die ebenfalls für die Vergleichsmethode CompareTo gilt, können Sie Tabelle 10.2 entnehmen.

Entscheidend darüber, wann ein Zeichen als größer oder kleiner im Vergleich zu einem zweiten gilt, ist die spezifische Ländereinstellung. Im mitteleuropäischen Sprachraum ist festgelegt, dass den Großbuchstaben ein größerer Wert zugeordnet ist als ihrem klein geschriebenen Pendant. Daher gilt:

Innerhalb von Groß- bzw. Kleinbuchstaben gilt die Reihenfolge, dass A < B < C bzw. a < b < c ist.

Ganz allgemein kann man die Sortierregel dann wie folgt beschreiben:

Compare durchläuft die beiden zu vergleichenden Zeichenfolgen Zeichen für Zeichen. Dabei wird zunächst die Wertigkeit eines Buchstabens im Alphabet festgestellt, bei Gleichheit zwischen Groß- und Kleinschreibung unterschieden.

CompareOrdinal vergleicht zwei Zeichenfolgen auf Basis der ANSI-Werte. Die Methode durchläuft dazu die beiden Zeichenfolgen Zeichen für Zeichen. Stimmt auch das letzte Zeichen in beiden Zeichenfolgen überein, ist der Rückgabewert 0. Stellt die Methode an einer Ordinalposition keine Übereinstimmung fest, bricht die Methode ab und liefert als Rückgabewert die Differenz der Zeichencodes. Tabelle 10.3 zeigt dies mit den Zeichenfolgen str1 und str2.

Fassen wir zum Abschluss noch einmal alle Vergleichsoperationen zur besseren Übersicht in einer Tabelle zusammen.

Suchen in einer Zeichenkette

Viele Aufgaben, die sich im Zusammenhang mit Zeichenfolgen stellen, beziehen sich auf die Suche nach einem bestimmten Zeichen oder nach einer Abfolge von Zeichen innerhalb einer Zeichenfolge. Das Ergebnis der Suche wird beispielsweise zur Konstruktion eines neuen Strings oder als Anweisung innerhalb einer anderen, äußeren Anweisung benötigt. Wir wollen uns im Folgenden diese Methoden und ihren Einsatz anschauen. Doch zunächst verschaffen wir uns einen ersten Überblick:

StartsWith

EndsWith

IndexOf

LastIndexOf

Substring

Fangen wir mit den beiden erstgenannten Methoden an, die in ihrer Funktionalität einander sehr ähnlich sind: StartsWith und EndsWith, mit denen der Anfang oder das Ende einer Zeichenfolge nach einer vorgegebenen Zeichensequenz überprüft wird. Beide liefern als Ergebnis ihres Aufrufs einen booleschen Wert zurück.

Die Anzahl der dem Parameter mitgeteilten Zeichen spielt keine Rolle, es kann sich um ein einzelnes handeln oder um eine Zeichenfolge. Mit

werden Sie demnach das Ergebnis true erhalten. In gleicher Weise lässt sich die Methode EndsWith einsetzen:

Beachten Sie, dass die Groß- und Kleinschreibung auch bei der Untersuchung einer Zeichenfolge berücksichtigt wird. Daher wird der Rückgabewert in diesem Fall false sein.

Mit IndexOf bzw. LastIndexOf lässt sich das erste oder das letzte Auftreten eines Zeichens oder einer Zeichenkette ermitteln. Beide Methoden sind vielfach überladen und erlauben die Übergabe eines char ebenso wie die Übergabe einer Zeichenfolge, nach der gesucht werden soll. Der Rückgabewert ist die Position des ersten Auftretens des Zeichens oder der Zeichen. Ist die Suche erfolglos, ist der Rückgabewert –1.

Im einfachsten Fall ähnelt die Funktionalität der beiden Methoden der von StartsWith und EndsWith. Die Überladung ermöglicht aber, die Suche ab einer bestimmten Position zu beginnen und – falls gewünscht – die Anzahl der Positionen anzugeben, in denen das Original mit dem Suchstring verglichen wird. Das folgende Beispiel demonstriert den Einsatz der IndexOf-Methode.

Wir geben zwar nur eine statische Zeichenfolge vor, aber das sollte uns in dieser Demonstration genügen. Gesucht wird in dieser Zeichenfolge der Teilstring »der«. Wir deklarieren zunächst die Variable pos, die in der folgenden do-Schleife als Positionszeiger dient und der das Ergebnis des Aufrufs IndexOf zugewiesen wird. Wird der gesuchte Teilstring gefunden, muss der Positionszeiger um eine Position verschoben werden, um nicht in einer Endlosschleife zu enden. Das hat aber zur Konsequenz, dass vor dem Eintritt in die Schleife pos mit –1 vorinitialisiert werden muss, damit die Suche beim ersten Schleifendurchlauf auch mit 0 startet.

Der Ausstieg aus der Schleife ist gewährleistet, wenn IndexOf das Ergebnis –1 liefert. Innerhalb des zu durchsuchenden Strings ist der Suchstring an den Positionen 8 und 20 enthalten. Beachten Sie, dass dem ersten Zeichen im zu durchsuchenden String der Index 0 zugeordnet ist.

Etwas allgemeiner gehalten ist die sehr flexibel einsetzbare Methode Substring, die überladen ist und aus einer gegebenen Zeichenfolge einen Teilstring zurückliefert. Substring wird in jedem Fall der Index der Startposition übergeben, ab der ein vorhandener String ausgewertet wird. Übergeben Sie einen zweiten Parameter, können Sie zudem die Anzahl der einzulesenden Zeichen ab der im ersten Parameter angegebenen Position festlegen. Wollen Sie beispielsweise die ersten sieben Zeichen einer Zeichenfolge einlesen, würde die Anweisung dazu wie folgt lauten:

Die Variable subStr wird den Inhalt »Projekt« haben. Benötigen Sie einen Teilabschnitt vom Ende eines Strings – nehmen wir an, die letzten acht Zeichen –, setzen Sie den Positionszeiger auf das erste einzulesende Zeichen, indem Sie von der Gesamtlänge des Strings die Anzahl der einzulesenden Zeichen subtrahieren:

Nun lautet der Inhalt von subStr »Explorer«.

Die Methoden »Trim« und »Pad«

Stellen Sie sich vor, Sie schreiben ein Programm, das auf eine Datenbank zugreift. In der Datenbank befindet sich eine Tabelle mit dem Kundenstamm eines Unternehmens. Aus dieser Tabelle soll ein ganz bestimmter Datensatz herausgegriffen werden, beispielsweise um die Kundendaten einzusehen oder zu ändern. Um nicht die gesamte Kundenliste der Reihe nach zu durchforsten (natürlich auch um die Ressourcen zu schonen und eine gute Performance der Anwendung zu gewährleisten), sollte der Anwender dazu aufgefordert werden, den Namen des Unternehmens anzugeben. Diese Eingabe wird nachfolgend dazu benutzt, in der Tabelle den passenden Datensatz zu suchen und ihn an den Anwender zurückzugeben.

Nehmen wir an, der Anwender sucht nach dem Unternehmen »Tollsoft GmbH« und gibt dazu das folgende Suchkriterium ein, nach dem der Kundenstamm der Tabelle durchsucht wird:

Fällt Ihnen etwas auf? Wenn nicht, dann sei Ihnen gesagt, Sie unterliegen demselben Fehler wie unser fiktiver Anwender – der Datensatz wird nämlich nicht gefunden. Der Grund ist ganz trivial: Vor dem Namen des Unternehmens steht – kaum bemerkbar – ein Leerzeichen. "Tollsoft GmbH" und " Tollsoft GmbH" sind aber unterschiedliche Firmennamen – zumindest aus Sicht des Programms. Fehler dieser Art schleichen sich sehr schnell ein und müssen daher schon bei der Programmentwicklung ausgeschlossen werden.

Die Klasse String stellt Ihnen dazu die Methoden Trim, TrimStart und TrimEnd zur Verfügung. Trim entfernt bestimmte Zeichen sowohl am Anfang als auch am Ende einer Zeichenfolge, TrimStart und TrimEnd bestimmte Zeichen am Anfang bzw. Ende einer Zeichenfolge.

Sehen wir uns die Definition der Methode Trim, die einfach überladen ist, an:

Die erste Variante wird auf ein String-Objekt aufgerufen und entfernt automatisch die Leerzeichen, die sich am Anfang und am Ende der Zeichenfolge befinden. Die parameterlose Trim-Methode ist damit spezialisiert auf Leerzeichen und dürfte in den meisten Anwendungsfällen genügen – natürlich auch in der, die anfangs beschrieben worden ist.

Die parametrisierte Version ist deutlich leistungsfähiger. Ihr wird ein char-Array übergeben, das diejenigen Zeichen enthält, die weder am Anfang noch am Ende der Zeichenfolge erlaubt sind. Das folgende Codefragment zeigt die Wirkungsweise der Methode.

Wir definieren das Array so, dass weder das Leerzeichen noch ein Punkt oder die Buchstaben A und m zugelassen sind. Die aus dem Aufruf der Trim-Methode resultierende Zeichenfolge wird lauten:

Sehr ähnlich arbeiten auch die beiden Methoden TrimStart und TrimEnd, die nicht überladen sind und ein char-Array als Übergabeparameter erwarten.

Die Methoden PadLeft und PadRight schneiden keine Zeichen an den Stringenden ab, sondern fügen bestimmte Zeichen entweder am Anfang oder Ende der Zeichenfolge hinzu. Auch diese Methoden sind überladen. Wir wollen uns kurz beide Parameterlisten anschauen:

Dieselbe Überladungsliste weist auch die Methode PadRight auf.

Die einfach parametrisierte Variante hängt Leerzeichen am Anfang (PadLeft) oder Ende (PadRight) der Zeichenfolge an. Der Integer gibt an, wie lang die am Ende resultierende Zeichenfolge insgesamt werden soll – also einschließlich der Anzahl der Zeichen des Strings selbst. Übergeben Sie einen Wert, der gleich oder kleiner der Länge der Zeichenfolge ist, verpufft der Methodenaufruf wirkungslos. Daher ist es sinnvoll, die Länge der Zeichenfolge zu bestimmen und dazu die Anzahl der gewünschten Leerzeichen zu addieren.

Wenn Sie ein anderes Zeichen am Anfang oder Ende des Strings wünschen, müssen Sie sich für die zweite Variante der Methode entscheiden. Dem zweiten Parameter übergeben Sie das gewünschte Zeichen als char:

Zeichenfolgen ändern

Bisher haben wir Strings verglichen, nach bestimmten Zeichensequenzen in einem String gesucht und am Anfang oder am Ende eines Strings Zeichen beliebiger Länge angehängt. Eine Reihe weiterer Methoden eröffnet uns die Möglichkeit, in der Zeichenfolge einzelne Zeichen zu manipulieren, indem wir sie durch andere ersetzen oder schlichtweg aus dem String löschen. Zu diesen Methoden gehören:

Insert

Remove

Replace

Split

ToUpper

ToLower

ToUpper und ToLower sind sehr einfach einzusetzen. Sie wandeln alle Zeichen einer Zeichenfolge entweder in Großbuchstaben (ToUpper) oder in Kleinbuchstaben (ToLower) um. Aus

wird mit

der Inhalt zu

Einsetzen oder Ersetzen eines Teilstrings

Manchmal ist es notwendig, eine Zeichenfolge ab einer bestimmten Position zu erweitern, ohne dabei aus dem Original Zeichen durch Überschreiben zu löschen. Hier spielt Insert seine Möglichkeiten aus:

Dem ersten Parameter übergeben Sie die Position, ab der die im zweiten Parameter genannte Zeichenkette eingefügt werden soll. Aus der Zeichenfolge

wollen wir die noch näher an der Wahrheit liegende Zeichenfolge

formulieren. Den String, den wir mittels Insert einfügen wollen, kennen wir. Was noch fehlt, ist die Position, ab der eingefügt werden soll. Dabei hilft IndexOf weiter:

Diese Methode liefert den Index des ersten Zeichens der übergebenen Zeichenfolge spitze, der als Einfügemarke für das zusätzliches Wort von Insert benutzt wird.

Mit Replace können Sie einen String – man sollte besser von einem Teilstring reden – durch einen anderen ersetzen. Replace ist aber nicht nur auf den Austausch einer bestimmten Zeichensequenz in einer Zeichenfolge beschränkt, es kann auch jedes Zeichen durch ein anderes ersetzt werden.

Der erste Parameter beschreibt das zu ersetzende Zeichen bzw. die zu ersetzende Zeichenfolge. Wodurch ersetzt werden soll, weiß der zweite Parameter zu berichten. Sollte Ihnen der Satz »Schule macht viel Spaß« nicht gefallen, können Sie ihn mit

in eine möglicherweise ehrlichere Aussage überführen.

Die »Split«-Methode

Es können Situationen auftreten, in denen mehrere Zeichenketten vorliegen, die Sie für eine bestimmte Operation wie eine einzige Zeichenkette behandeln wollen. Stellen Sie sich dazu vor, Sie möchten Ihre Adresse über das Netzwerk einer anderen Person mitteilen. Dazu können Sie zuerst Ihren Vornamen bekannt geben, im Anschluss daran Ihre Zunamen, schließlich den Wohnort usw. Besser wäre es, die vollständige Information in einem String zu verschicken und sich mit dem Empfänger auf ein Format zu einigen, nach dem der übermittelte String wieder in seine ursprünglichen Einzelstrings zerlegt werden kann und die Substrings zu interpretieren sind. Schließlich müssen beide Parteien wissen, ob es sich bei »Otto« um den Vor- oder Zunamen handelt.

Neben der Interpretationsreihenfolge ist ein als Separator dienendes Zeichen, das die Teilzeichenfolgen voneinander trennt, festzulegen. Haben sich Sender und Empfänger darüber geeinigt, lässt sich die beim Empfänger eingehende Zeichenfolge in die ursprünglichen Teilstrings zerlegen.

Die String-Klasse unterstützt mit ihrer Methode Split das eben beschriebene Szenario des Zerlegens einer Zeichenfolge in Teilstrings. Schauen wir uns zunächst einmal die Definition der Split-Methode an:

Die Methode durchsucht den String, auf den Split aufgerufen wird, nach den spezifizierten Separatoren, die dem Parameter mitgeteilt werden. Da dieser Parameter als params definiert ist, können durchaus mehrere verschiedene Trennzeichen definiert werden. Das eröffnet Interpretationsmöglichkeiten hinsichtlich der Teilzeichenfolgen. So könnten Sie beispielsweise festlegen, dass als Separator zwischen dem Vor- und dem Zunamen ein Semikolon benutzt wird, zwischen dem Zunamen und dem Wohnort ein Ausrufezeichen usw. Die einzelnen Teilstrings werden in einem String-Array an den Aufrufer zurückgegeben.

Wir wollen uns die Arbeitsweise dieser etwas komplexeren Methode an einem Beispiel verdeutlichen und legen dazu fest, das Semikolon als Separator zu benutzen. Eine Methode, die in der Lage ist, eine ihr übergebene Zeichenfolge wieder in die ursprünglichen Teilstrings zu zerlegen, könnte wie folgt aussehen:

Dem Aufruf der Methode GetSubstrings wird eine Zeichenfolge übergeben, deren Teilstrings durch ein Semikolon getrennt sind. In der Methode wird der String in seine Teilstrings zerlegt und dem Array myStr zugewiesen. Die Aufsplittung erfolgt mit der Split-Methode auf das Objekt obj. Der Semikolon-Separator wird der Split-Methode als Argument übergeben. In den einzelnen Elementen des String-Arrays liegen danach alle Teilzeichenfolgen vor, die in einer Schleife der Reihe nach an der Konsole angezeigt werden.

Nun wollen wir die Methode testen und entwickeln dazu ein kleines Beispielprogramm:

Der Konvention folgend ist bis auf die Angabe des Wohnortes hinter jedem String ein Strichpunkt als Abschluss gesetzt. Jeder String wird als Element eines Arrays gespeichert.

Um aus allen Teilstrings einen einzigen zu erstellen, könnten wir mit dem »+«-Operator arbeiten, aber die Klasse String bietet uns eine Alternative in Form der Methode Concat an, die dazu dient, aus mehreren Einzelstrings einen einzigen Gesamtstring zu erzeugen. Concat ist, um den vielfältigen Anforderungen, die sich bei der String-Verknüpfung ergeben, gerecht zu werden, überladen. Im Beispielcode fiel die Entscheidung auf die überladene Methode, die als Argument ein String-Array erwartet und aus allen Array-Elementen einen einzigen String formuliert, der unserer benutzerdefinierten Methode GetSubstrings übergeben wird.

Die Ausgabe an der Konsole beweist die korrekte Interpretation, der übergebene String wird wieder in seine ursprünglichen Substrings zerlegt. Beachten Sie, dass die Split-Methode die Trennzeichen im String erkennt und weiß, dass diese nicht zu den einzelnen String-Objekten gehören. Sie werden deshalb automatisch entfernt.

Zeichenfolgen und »char«-Arrays

Sie werden, wenn Sie sich intensiver mit den Klassen des .NET Frameworks beschäftigen, immer wieder auf Methoden treffen, die Parameter vom Typ entweder eines char-Arrays oder vom Typ string deklarieren. Je nach Ausgangssituation im Programm ist dann die Umwandlung eines char-Arrays in string oder umgekehrt notwendig.

Aus einem char-Array einen String zu erzeugen, haben Sie bereits am Anfang dieses Abschnitts gesehen: Sie übergeben dem passenden string-Konstruktor die Referenz auf das Array, beispielsweise:

Der umgekehrte Weg, die einzelnen Zeichen einer string-Referenz in ein char-Array zu schreiben, scheint ein wenig kniffliger zu sein. Mit den bisher gezeigten Methoden der Klasse String sollte das kein allzu großes Problem sein, aber die .NET-Baumeister haben Ihnen diese Arbeit bereits abgenommen, wie ein Blick in die Dokumentation der String-Klasse verrät. Diese veröffentlicht die Methode ToCharArray:

Entscheiden Sie sich für die parameterlose Methode, werden die Zeichen des gesamten Strings, auf dem die Methode aufgerufen wird, einem char-Array zugewiesen. Wollen Sie ab einer bestimmten Position einen Teil des Strings einem char-Array zuweisen, entscheiden Sie sich für die parametrisierte ToCharArray-Methode.

Das folgende Codefragment benutzt die parameterlose Methode, um das Array zu füllen und anschließend die einzelnen Elemente zeilenweise an der Konsole auszugeben.

An der Konsole wird das Wort, das ursprünglich durch einen String gebildet wurde, nun Buchstabe für Buchstabe in je einer Zeile angezeigt.

10.2.5 Zusammenfassung der Klasse »String« 

Zum Abschluss unserer Betrachtungen der Klasse String wollen wir des besseren Gesamtüberblicks wegen in tabellarischer Form noch einmal alle in diesem Abschnitt erwähnten Methoden auflisten.